#[cfg(test)]
mod tests {
    use dotenvy::dotenv;
    use serde_json::{from_str, Value};
    use gateway::jsonrpc_common::{create_error_response, JsonRpcRequest};
    use log::info;

    #[test]
    fn test_from_string() {
        let json_str = r#"{
    "method": "asset.query",
    "params": [1001,1,2],
       "params1": [1001,1,2,9999999999999999999999],
    "id": 1,
    "jsonrpc": "2.0"
}"#;
        let json: serde_json::Value = from_str(json_str).unwrap();
        let req:JsonRpcRequest = from_str::<JsonRpcRequest>(json_str).unwrap();
        // match from_str::<JsonRpcRequest>(json_str) {
        //     Ok(obj) => {
        //         println!("{:?}", obj); // 输出: MyObject { name: "Alice", age: 30 }
        //     }
        //     Err(e) => {
        //         println!("Error parsing JSON: {}", e);
        //     }
        // }

        // let params = req.params.as_ref().unwrap(); // &Value
        let params = req.params.as_ref().unwrap().as_array().unwrap();

        // let params: Vec<String> = serde_json::from_value(req.params);

        // let params = match req.params {
        //     Value::Array(arr) => arr,
        //     // Value::Null => Vec::new(),
        //     Some(_) => Err(Error::custom("params must be an array")),
        //     // _ => return Err(Error::InvalidParams("Expected array or null".into())),
        // };


        // if let Some(params) = req.params.unwrap().as_array() {
        //     let vec_params: Vec<Value> = params.to_vec();
        //     // 使用vec_params
        // }
        //
        // let params = match req.params.as_ref() {
        //     Some(Value::Array(params))  => params,
        //     // _ => &vec![],
        //     _ =>  panic!("Params cannot be null!")
        // };

        // // 遍历params
        // for param in params {
        //     println!("Parameter: {:?}", param);
        //     // 根据param类型进行不同处理
        //     match param {
        //         Value::String(s) => println!("String value: {}", s),
        //         Value::Number(n) => println!("Number value: {}", n),
        //         Value::Bool(b) => println!("Boolean value: {}", b),
        //         _ => println!("Other type")
        //     }
        // }
        // let params: Vec<String> = req.params
        //     .as_ref()
        //     .and_then(|v| v.as_array())
        //     .expect("Expected array params")
        //     .iter()
        //     .map(|v| v.as_str().expect("Expected string").to_string())
        //     .collect();
        //
        // for param in &params {
        //     println!("String param: {}", param);
        // }

        // let v2:Vec<u16> = get_u16_slice(&req);
        // 获取assets的列表,从第2个(index=1)切片
        let assets = &params[1..];
        // 数组转vec[u16]
        let v:Vec<u16> = assets
           .iter()
            .map(|v| {
                v.as_u64()
                    .ok_or("Parameter is not a number")
                    .and_then(|n| u16::try_from(n).map_err(|_| "Number too large for u16")).unwrap()
            })
            .collect();

        // let v:Vec<u16> = params.iter()
        //     .skip(1)
        //     .map(|v| {
        //         v.as_u64()
        //             .ok_or("Parameter is not a number")
        //             .and_then(|n| u16::try_from(n).map_err(|_| "Number too large for u16")).unwrap()
        //     })
        //
        //     .collect();

        // let n = params.get("USDT").unwrap();
        let sz = params.len();
        info!("req: {:?}", req);
    }

    fn get_u16_slice(request: &JsonRpcRequest) -> Vec<u16> {
        let params = match &request.params {
            Some(Value::Array(arr)) => arr,
            _ => panic!("Expected array params")
        };

        // 从第2个元素开始（索引1）获取切片并转换为u16
        params.iter()
            .skip(1)  // 跳过第一个元素
            .map(|v| {
                // 转换为u16，处理可能的错误
                match v.as_u64() {
                    Some(n) => u16::try_from(n)
                        .expect("Number too large for u16"),
                    None => panic!("Expected number, got: {:?}", v)
                }
            })
            .collect()
    }
    #[test]
    fn call_test_from_string() {
        // dotenv().ok();
        env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
        info!("test_from_string...");
        test_from_string();
        info!("test_from_string ok");
    }
}
